// polyfill.js - 提供类型化数组和define的polyfill

// 适配微信小程序环境中的全局对象
const getGlobalObject = () => {
  try {
    if (typeof wx !== 'undefined') {
      // 小程序特有的全局对象处理
      return typeof global !== 'undefined' ? global : {}; 
    }
    
    if (typeof globalThis !== 'undefined') return globalThis;
    if (typeof window !== 'undefined') return window;
    if (typeof global !== 'undefined') return global;
    if (typeof self !== 'undefined') return self;
    return {};
  } catch (e) {
    // 如果出现任何错误，返回一个空对象作为后备
    console.error('无法获取全局对象:', e);
    return {};
  }
};

try {
  const globalObj = getGlobalObject();
  
  // 添加类型化数组的polyfill
  const typeArrays = [
    'Int8Array',
    'Uint8Array',
    'Uint8ClampedArray',
    'Int16Array', 
    'Uint16Array',
    'Int32Array',
    'Uint32Array',
    'Float32Array',
    'Float64Array'
  ];
  
  // 为每个不存在的类型化数组创建polyfill
  typeArrays.forEach(typeName => {
    try {
      if (typeof globalObj[typeName] === 'undefined') {
        // 使用普通数组作为polyfill
        globalObj[typeName] = function(arg) {
          // 可以接受长度或数组作为参数
          if (typeof arg === 'number') {
            return new Array(arg);
          } else if (Array.isArray(arg)) {
            return Array.from(arg);
          } else if (arg && typeof arg === 'object' && 'length' in arg) {
            return Array.from(arg);
          }
          return [];
        };
        
        // 添加BYTES_PER_ELEMENT属性
        let bytesPerElement = 1;
        if (typeName.includes('16')) bytesPerElement = 2;
        if (typeName.includes('32')) bytesPerElement = 4;
        if (typeName.includes('64')) bytesPerElement = 8;
        
        globalObj[typeName].BYTES_PER_ELEMENT = bytesPerElement;
        
        // 添加from和of静态方法
        globalObj[typeName].from = Array.from;
        globalObj[typeName].of = Array.of;
        
        // 给prototype添加所需方法
        const proto = globalObj[typeName].prototype;
        proto.forEach = Array.prototype.forEach;
        proto.map = Array.prototype.map;
        proto.slice = Array.prototype.slice;
        proto.subarray = Array.prototype.slice;
        proto.set = function(array, offset) {
          offset = offset || 0;
          for (let i = 0; i < array.length; i++) {
            this[offset + i] = array[i];
          }
        };
      }
    } catch (e) {
      console.error(`为 ${typeName} 添加 polyfill 失败:`, e);
    }
  });
  
  // 确保define函数存在，解决"define is not defined"错误
  try {
    if (typeof globalObj.define === 'undefined') {
      globalObj.define = function(name, deps, callback) {
        // 简单的AMD模块加载polyfill
        try {
          if (typeof callback === 'function') {
            // 执行回调
            const modules = deps.map(dep => {
              if (dep === 'require') return function() { return {}; };
              if (dep === 'exports') return {};
              if (dep === 'module') return { exports: {} };
              return null;
            });
            return callback.apply(null, modules);
          } else if (typeof deps === 'function') {
            // 直接执行函数
            return deps();
          }
        } catch (e) {
          console.error('执行define回调失败:', e);
        }
      };
      
      // 添加AMD属性
      globalObj.define.amd = {};
    }
  } catch (e) {
    console.error('添加define函数失败:', e);
  }
  
  // 导出全局对象
  module.exports = globalObj;
} catch (e) {
  console.error('初始化polyfill失败:', e);
  module.exports = {};
}
